package org.example.springboot.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jakarta.annotation.Resource;
import org.example.springboot.common.Result;
import org.example.springboot.entity.*;
import org.example.springboot.mapper.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.List;

/**
 * 出库申请服务类
 * 处理出库申请的创建、修改、审批、查询等业务逻辑
 * 包括领用出库和销售出库两种类型
 */
@Service
public class OutstockApplyService {
    private static final Logger LOGGER = LoggerFactory.getLogger(OutstockApplyService.class);
//操作出库申请表
    @Resource
    private OutstockApplyMapper outstockApplyMapper;
    //获取用户信息
    @Resource
    private UserMapper userMapper;
    //获取商品信息；
    @Resource
    private GoodsInfoMapper goodsInfoMapper;
    //获取仓库信息；
    @Resource
    private WarehouseInfoMapper warehouseInfoMapper;
//库存相关数据访问层；
    @Resource
    private InventoryMapper inventoryMapper;
    @Resource
    private InventoryHistoryMapper inventoryHistoryMapper;

    @Resource
    private InventoryAlertMapper inventoryAlertMapper;
//库存业务逻辑处理服务，用于更新库存数量。
    @Resource
    private InventoryService inventoryService;

    /**
     * 创建出库申请
     * @param apply 出库申请信息，包含申请类型、商品ID、数量、申请人ID等
     * @return 创建结果
     * 业务流程：
     * 1. 验证商品是否存在
     * 2. 验证申请人是否存在
     * 3. 设置初始状态为待审批(0)
     * 4. 设置创建时间
     * 5. 保存申请记录
     */
    public Result<?> createApply(OutstockApply apply) {
        // 验证商品是否存在
        if (goodsInfoMapper.selectById(apply.getGoodsId()) == null) {
            return Result.error("-1", "商品不存在");
        }

        // 验证申请人是否存在
        if (userMapper.selectById(apply.getApplicantId()) == null) {
            return Result.error("-1", "申请人不存在");
        }

        // 设置初始状态和创建时间
        apply.setStatus(0); // 待审批状态
        apply.setCreateTime(new Timestamp(System.currentTimeMillis()));
        //插入数据库并返回结果
        int result = outstockApplyMapper.insert(apply);
        return result > 0 ? Result.success(apply) : Result.error("-1", "创建出库申请失败");
    }

    /**
     * 更新出库申请
     * @param id 出库申请的唯一标识
     * @param apply 更新的申请信息
     * @return 更新结果
     * 业务规则：
     * 1. 只能修改待审批状态(0)的申请
     * 2. 更新时自动更新修改时间
     */
    public Result<?> updateApply(Long id, OutstockApply apply) {
        //查询原申请是否存在：
        OutstockApply existingApply = outstockApplyMapper.selectById(id);
        if (existingApply == null) {
            return Result.error("-1", "出库申请不存在");
        }

        // 判断是否是待审批状态（只能修改未审批的申请）
        if (existingApply.getStatus() != 0) {
            return Result.error("-1", "该申请已审批，无法修改");
        }
       //设置更新时间和 ID 后进行更新：
        apply.setId(id);
        apply.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        int result = outstockApplyMapper.updateById(apply);
        return result > 0 ? Result.success(apply) : Result.error("-1", "更新出库申请失败");
    }

    /**
     * 审批出库申请
     * @param id 申请ID
     * @param approvalStatus 审批状态（1：通过，2：拒绝）
     * @param approvalComment 审批意见
     * @param approverId 审批人ID
     * @return 审批结果
     * 业务流程：
     * 1. 验证申请是否存在且状态为待审批(0)
     * 2. 更新审批状态、意见、审批人、审批时间
     * 3. 如果审批通过，调用库存服务更新库存数量
     * 4. 如果库存不足或更新失败，自动将审批状态改为拒绝(2)
     */
    @Transactional
    public Result<?> approveApply(Long id, Integer approvalStatus, String approvalComment, Long approverId) {
        //查询申请是否存在且状态为待审批：
        OutstockApply apply = outstockApplyMapper.selectById(id);
        if (apply == null) {
            return Result.error("-1", "出库申请不存在");
        }

        // 只能审批待审批状态的申请
        if (apply.getStatus() != 0) {
            return Result.error("-1", "该申请已审批");
        }
        // 更新审批状态
        apply.setStatus(approvalStatus);
        apply.setApprovalComment(approvalComment);
        apply.setApproverId(approverId);
        apply.setApprovalTime(new Timestamp(System.currentTimeMillis()));
        apply.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        // 调用库存服务减少库存（出库类型为 2）
        Result<?> updateResult = inventoryService.updateInventory(
            apply.getGoodsId(),
            apply.getWarehouseId(),
            BigDecimal.valueOf(apply.getQuantity()),
            2, // 出库类型
            approverId
        );
        //如果库存更新失败，自动将审批状态改为拒绝：
        if (!updateResult.getCode().equals("0")) {
            apply.setStatus(2);
            apply.setApprovalTime(new Timestamp(System.currentTimeMillis()));
            apply.setApprovalComment(updateResult.getMsg());

        }


        //更新申请状态到数据库：
        int result = outstockApplyMapper.updateById(apply);
        return result > 0 ? Result.success(apply) : Result.error("-1", "审批失败");
    }

    /**
     * 获取出库申请详情
     * @param id 申请ID
     * @return 申请详情，包含关联的申请人、商品、仓库、审批人信息
     * 关联信息：
     * 1. 申请人信息
     * 2. 商品信息
     * 3. 仓库信息
     * 4. 审批人信息（如果已审批）
     */
    public Result<?> getApplyById(Long id) {
        //查询申请基本信息
        OutstockApply apply = outstockApplyMapper.selectById(id);
        if (apply == null) {
            return Result.error("-1", "出库申请不存在");
        }

        // 关联查询申请人信息
        User applicant = userMapper.selectById(apply.getApplicantId());
        apply.setApplicant(applicant);

        // 关联查询商品信息
        GoodsInfo goodsInfo = goodsInfoMapper.selectById(apply.getGoodsId());
        apply.setGoodsInfo(goodsInfo);

        // 关联查询仓库信息
        WarehouseInfo warehouse = warehouseInfoMapper.selectById(apply.getWarehouseId());
        apply.setWarehouse(warehouse);
     //关联查询审批人信息（如果已审批）
        if (apply.getApproverId() != null) {
            User approver = userMapper.selectById(apply.getApproverId());
            apply.setApprover(approver);
        }

        return Result.success(apply);
    }

    /**
     * 分页查询出库申请列表
     * @param applyType 申请类型（1：领用出库，2：销售出库）
     * @param status 审批状态（0：待审批，1：已通过，2：已拒绝）
     * @param applicantId 申请人ID
     * @param currentPage 当前页码
     * @param pageSize 每页记录数
     * @return 分页结果，包含申请列表及关联信息
     * 查询特点：
     * 1. 支持按申请类型、状态、申请人筛选
     * 2. 按创建时间倒序排序
     * 3. 自动关联申请人、商品、仓库、审批人信息
     */
    public Result<?> getApplysByPage(Integer applyType, Integer status, Long applicantId, 
                                   Integer currentPage, Integer pageSize) {
        //构建查询条件：
        LambdaQueryWrapper<OutstockApply> wrapper = new LambdaQueryWrapper<>();
        
        if (applyType != null) {
            wrapper.eq(OutstockApply::getApplyType, applyType);
        }
        if (status != null) {
            wrapper.eq(OutstockApply::getStatus, status);
        }
        if (applicantId != null) {
            wrapper.eq(OutstockApply::getApplicantId, applicantId);
        }
        
        // 按创建时间倒序排序
        wrapper.orderByDesc(OutstockApply::getCreateTime);
        //分页查询：
        
        Page<OutstockApply> page = outstockApplyMapper.selectPage(new Page<>(currentPage, pageSize), wrapper);
        
        // 关联查询申请人信息
        page.getRecords().forEach(apply -> {
            User applicant = userMapper.selectById(apply.getApplicantId());
            apply.setApplicant(applicant);
            // 关联查询商品信息
            GoodsInfo goodsInfo = goodsInfoMapper.selectById(apply.getGoodsId());
            apply.setGoodsInfo(goodsInfo);
          //关联查询审批人信息
            if (apply.getApproverId() != null) {
                User approver = userMapper.selectById(apply.getApproverId());
                apply.setApprover(approver);
            }
        //关联查询仓库信息
            WarehouseInfo warehouse = warehouseInfoMapper.selectById(apply.getWarehouseId());
            apply.setWarehouse(warehouse);
        });
        
        return Result.success(page);
    }

    /**
     * 删除单个出库申请
     * @param id 申请ID
     * @return 删除结果
     * 业务规则：
     * 1. 只能删除待审批状态(0)的申请
     * 2. 已审批的申请不允许删除
     */
    public Result<?> deleteApply(Long id) {
        //查询申请是否存在：
        OutstockApply apply = outstockApplyMapper.selectById(id);
        if (apply == null) {
            return Result.error("-1", "出库申请不存在");
        }

        //判断是否是待审批状态（已审批的不能删除）：
        if (apply.getStatus() != 0) {
            return Result.error("-1", "已审批的申请不能删除");
        }
        //删除申请：
        int result = outstockApplyMapper.deleteById(id);
        return result > 0 ? Result.success() : Result.error("-1", "删除出库申请失败");
    }
//功能：批量删除出库申请。
    //ids：需要删除的申请 ID 列表。
    //return:成功：Result.success()；
//失败：Result.error("-1", "出库申请ID xxx 不存在 或 已审批")。
    public Result<?> deleteBatch(List<Long> ids) {
        // 遍历所有 ID，检查是否存在且状态为待审批：
        for (Long id : ids) {
            OutstockApply apply = outstockApplyMapper.selectById(id);
            if (apply == null) {
                return Result.error("-1", "出库申请ID " + id + " 不存在");
            }
            if (apply.getStatus() != 0) {
                return Result.error("-1", "已审批的申请不能删除");
            }
        }
//批量删除：
        int result = outstockApplyMapper.deleteBatchIds(ids);
        return result > 0 ? Result.success() : Result.error("-1", "批量删除出库申请失败");
    }
}